import requests
import json
import re
import argparse
import sys
import os
from bs4 import BeautifulSoup
from urllib.parse import urljoin, urlparse
from collections import defaultdict, deque


class WebResourceAnalyzer:
    """智能网页和文件系统资源分析工具"""
    
    def __init__(self):
        # URL队列
        self.target_urls = deque()
        
        # 记录已经爬取过的网站，避免重复爬取
        self.crawled_urls = set()
        
        # 定义目标关键词，用于识别感兴趣的链接（可通过命令行参数覆盖）
        self.target_keywords = [
            '新闻', '热点', '科技', '人工智能', 'AI', '技术', '创新', 
            '发展', '趋势', '研究', '分析', '报告', '数据', '统计'
        ]
        
        # 存储页面总结
        self.page_summaries = []
        
        # 默认提示词模板
        self.default_prompts = {
            "link_identifier": """你是一个专业的网页链接识别专家。你的任务是从当前页面中找出可能包含目标内容的链接，并使用工具函数将它们添加到爬取队列中。

## 目标关键词：
{keywords}

## 你的职责：
1. 分析当前页面的所有链接
2. 识别与目标关键词相关的链接
3. 评估每个链接的相关性和价值
4. 选择最有价值的链接添加到队列

## 选择标准：
- **高优先级**：链接文本或URL明显包含目标关键词
- **中优先级**：链接指向的内容类型与目标相关（如新闻、文章、博客等）
- **低优先级**：链接可能有相关内容的间接线索

## 注意事项：
- 专注于识别链接，不要分析具体页面内容
- 优先选择权威网站和高质量来源
- 避免添加重复或明显无关的链接
- 考虑链接的上下文和周围文本

请使用工具函数将3-8个最有价值的链接添加到爬取队列中，并为每个链接提供选择理由和置信度评估。""",
            
            "content_analyzer": """你是一个专业的内容分析专家。请对当前资源进行深入分析，提取关键信息并评估内容质量。

## 分析要求：

### 1. 内容总结
- 用简洁的语言概括主要内容
- 提取核心观点和关键信息

### 2. 质量评估
- **优秀**：内容详实、结构清晰、来源可靠、信息新颖
- **良好**：内容完整、有一定价值、来源可信
- **一般**：内容简单、信息有限、价值一般
- **较差**：内容空洞、信息过时、来源不可靠

### 3. 内容类型识别
- 新闻报导、技术文章、博客帖子、论坛讨论
- 产品页面、文档资料、数据报告、学术论文
- 电子商务、门户网站、社交媒体、个人网站

### 4. 主题标签
- 提取3-8个最能代表内容主题的关键词
- 涵盖主要话题和细分领域

## 注意事项：
- 保持客观公正的评价
- 关注内容的实用性和信息密度
- 考虑目标受众和内容定位
- 注意内容的时效性和权威性

请提供全面的内容分析，帮助用户快速了解资源价值。""",
            
            "spider": """你是一个智能网页爬虫助手。你的任务是分析页面内容并识别有价值的信息和链接。

## 你的职责：

### 1. 内容分析
- 识别页面的主要内容和主题
- 提取关键信息和亮点
- 评估内容的独特性和价值

### 2. 链接识别
- 发现可能包含目标内容的链接
- 评估链接的相关性和质量
- 识别导航链接和内容链接

### 3. 上下文理解
- 分析页面在网站结构中的位置
- 理解内容的组织和分类
- 识别相关内容集群

## 目标关键词：
{keywords}

## 分析重点：
- 寻找深度内容（长篇文章、研究报告等）
- 识别权威来源和专家内容
- 关注时效性信息和最新动态
- 发现数据驱动的分析和统计

## 输出要求：
- 提供对页面的整体评价
- 识别最有价值的内容元素
- 建议下一步的爬取方向

请综合分析页面内容，为后续爬取提供智能指导。""",
            
            "file_analyzer": """你是一个文件内容分析专家。专门分析本地文件系统中的文档和资料。

## 支持的文件类型：
- HTML/HTM：网页文件
- TXT：纯文本文件
- MD：Markdown文档
- JSON：数据文件
- XML：结构化文档

## 分析重点：

### 1. 文件结构分析
- 文档的组织结构和层次
- 章节划分和内容布局
- 数据格式和编码规范

### 2. 内容价值评估
- 信息的完整性和准确性
- 知识的深度和广度
- 实用价值和应用场景

### 3. 主题识别
- 主要话题和次要话题
- 技术领域和应用方向
- 相关概念和术语

### 4. 链接分析（针对HTML）
- 内部链接和外部链接
- 资源引用和依赖关系
- 导航结构和网站地图

## 目标关键词：
{keywords}

## 注意事项：
- 注意文件的编码和格式兼容性
- 识别文件在项目或文档集中的位置
- 评估文件的维护状态和更新频率

请提供专业的文件内容分析，帮助用户理解文档价值。"""
        }

    def parse_arguments(self):
        """解析命令行参数"""
        parser = argparse.ArgumentParser(description='智能网页和文件系统资源分析工具')
        parser.add_argument('--iterations', '-i', type=int, default=10,
                          help='最大迭代次数（默认：10）')
        parser.add_argument('--keywords', '-k', type=str, 
                          help='目标关键词，用逗号分隔（例如："新闻,科技,AI"）')
        parser.add_argument('--api-key-file', type=str, default="deepseek.key",
                          help='API密钥文件路径（默认：deepseek.key）')
        parser.add_argument('--urls-file', type=str, default="",
                          help='初始URL文件路径（可选）')
        parser.add_argument('--prompt-files', type=str, 
                          default="prompts/link_identifier.txt,prompts/content_analyzer.txt,prompts/spider.txt",
                          help='提示词文件路径，用逗号分隔（默认：link_identifier,content_analyzer,spider）')
        parser.add_argument('--local-base-dir', type=str, default="",
                          help='本地文件系统基础目录，用于解析相对文件路径')
        parser.add_argument('--auto-select-prompt', action='store_true',
                          help='根据URL类型自动选择合适的提示词')
        parser.add_argument('urls', nargs='*', default=[],
                          help='要分析的目标URL列表（支持http/https/file://协议）')
        
        return parser.parse_args()

    def load_urls_from_args_and_file(self, args):
        """从命令行参数和文件加载初始URL队列"""
        urls_loaded = []
        
        # 首先从命令行参数加载URL
        if args.urls:
            self.target_urls.extend(args.urls)
            urls_loaded.extend(args.urls)
            print(f"✅ 从命令行参数加载了 {len(args.urls)} 个URL")
        
        # 然后从文件加载URL（如果提供了文件）
        if args.urls_file:
            try:
                with open(args.urls_file, 'r', encoding='utf-8') as f:
                    data = json.load(f)
                    if isinstance(data, list):
                        file_urls = data
                    elif isinstance(data, dict) and 'urls' in data:
                        file_urls = data['urls']
                    else:
                        file_urls = []
                    
                    # 添加到队列中
                    self.target_urls.extend(file_urls)
                    urls_loaded.extend(file_urls)
                    print(f"✅ 从 {args.urls_file} 加载了 {len(file_urls)} 个URL")
                    
            except FileNotFoundError:
                print(f"⚠️  URL文件不存在: {args.urls_file}")
            except Exception as e:
                print(f"❌ 加载URL文件失败: {e}")
        
        # 如果没有任何URL，使用默认URL
        if not self.target_urls:
            default_url = 'https://www.sohu.com'
            self.target_urls.append(default_url)
            urls_loaded.append(default_url)
            print(f"ℹ️  未提供URL，使用默认URL: {default_url}")
        
        print(f"🎯 总共加载了 {len(urls_loaded)} 个初始URL")
        return urls_loaded

    def update_keywords(self, keywords_str):
        """更新目标关键词"""
        if keywords_str:
            new_keywords = [kw.strip() for kw in keywords_str.split(',') if kw.strip()]
            if new_keywords:
                self.target_keywords = new_keywords
                print(f"🎯 已更新目标关键词: {', '.join(self.target_keywords)}")
            else:
                print("⚠️  提供的关键词为空，使用默认关键词")
        else:
            print("ℹ️  未提供关键词参数，使用默认关键词")

    def mark_url_as_crawled(self, url):
        """标记URL为已爬取"""
        self.crawled_urls.add(url)
        print(f"📝 已标记为已爬取: {url}")

    def is_url_crawled(self, url):
        """检查URL是否已经爬取过"""
        return url in self.crawled_urls

    def get_crawled_urls_count(self):
        """获取已爬取的URL数量"""
        return len(self.crawled_urls)

    def load_file(self, file_path):
        """从文件加载内容"""
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                return f.read().strip()
        except FileNotFoundError:
            print(f"⚠️  文件不存在: {file_path}")
            # 根据文件名返回不同的默认提示词
            filename = os.path.basename(file_path).lower()
            for prompt_type, prompt_content in self.default_prompts.items():
                if prompt_type in filename:
                    return prompt_content
            return "请分析这个资源的内容。"
        except Exception as e:
            print(f"❌ 加载文件失败: {file_path}, 错误: {e}")
            return "请分析这个资源的内容。"

    def auto_select_prompt(self, url, available_prompts):
        """根据URL类型自动选择合适的提示词"""
        parsed = urlparse(url)
        
        if parsed.scheme == 'file':
            # 对于文件URL，优先使用file_analyzer
            file_prompts = [p for p in available_prompts if 'file_analyzer' in p]
            if file_prompts:
                return file_prompts[0]
        
        # 对于网页，根据可用提示词选择
        if 'content_analyzer' in available_prompts:
            return 'content_analyzer'
        elif 'spider' in available_prompts:
            return 'spider'
        elif 'link_identifier' in available_prompts:
            return 'link_identifier'
        else:
            return available_prompts[0] if available_prompts else 'link_identifier'

    def fetch_file_content(self, file_path):
        """
        读取本地文件内容
        """
        try:
            print(f"📁 正在读取本地文件: {file_path}")
            
            # 检查文件是否存在
            if not os.path.exists(file_path):
                raise FileNotFoundError(f"文件不存在: {file_path}")
            
            # 检查是否为文本文件（根据扩展名简单判断）
            text_extensions = ['.txt', '.html', '.htm', '.md', '.json', '.xml', '.csv', '.log', '.py', '.js', '.java', '.cpp', '.c']
            file_ext = os.path.splitext(file_path)[1].lower()
            
            if file_ext not in text_extensions:
                return f"⚠️ 文件类型 {file_ext} 可能不是文本文件，跳过详细内容分析", []
            
            # 读取文件内容
            try:
                with open(file_path, 'r', encoding='utf-8') as f:
                    content = f.read()
            except UnicodeDecodeError:
                # 如果UTF-8失败，尝试其他编码
                try:
                    with open(file_path, 'r', encoding='gbk') as f:
                        content = f.read()
                except:
                    return f"❌ 无法读取文件编码: {file_path}", []
            
            # 提取文件中的链接（在HTML文件中）
            links = []
            if file_ext in ['.html', '.htm']:
                soup = BeautifulSoup(content, 'html.parser')
                for link in soup.find_all('a', href=True):
                    href = link['href']
                    absolute_url = urljoin(f"file://{os.path.abspath(file_path)}", href)
                    
                    if self.is_valid_url(absolute_url):
                        link_text = link.get_text(strip=True)
                        relevance_score = self.calculate_relevance_score(link_text, absolute_url)
                        
                        links.append({
                            'url': absolute_url,
                            'text': link_text,
                            'full_info': f"链接: {link_text} -> {absolute_url} [相关性: {link_text} {relevance_score}/10]",
                            'relevance_score': relevance_score
                        })
            
            print(f"✅ 成功读取文件内容，字符数: {len(content)}，发现链接数: {len(links)}")
            return content, links
            
        except Exception as e:
            print(f"❌ 文件读取失败: {e}")
            raise Exception(f"文件读取失败: {e}")

    def fetch_webpage_content(self, url):
        """
        爬取网页内容并提取所有链接
        """
        try:
            # 检查是否已经爬取过
            if self.is_url_crawled(url):
                print(f"⏭️  跳过已爬取的URL: {url}")
                return "", []
                
            headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
            }
            
            print(f"🌐 开始爬取: {url}")
            response = requests.get(url, headers=headers, timeout=15)
            response.raise_for_status()
            
            soup = BeautifulSoup(response.content, 'html.parser')
            
            # 移除脚本和样式标签
            for script in soup(["script", "style"]):
                script.decompose()
            
            # 获取文本内容
            text_content = soup.get_text(separator='\n', strip=True)
            
            # 清理多余的空行
            lines = [line.strip() for line in text_content.splitlines() if line.strip()]
            cleaned_content = '\n'.join(lines)
            
            # 提取页面中的所有链接
            links = []
            for link in soup.find_all('a', href=True):
                href = link['href']
                absolute_url = urljoin(url, href)
                
                # 过滤无效链接
                if self.is_valid_url(absolute_url):
                    link_text = link.get_text(strip=True)
                    # 计算链接与目标关键词的相关性分数
                    relevance_score = self.calculate_relevance_score(link_text, absolute_url)
                    
                    links.append({
                        'url': absolute_url,
                        'text': link_text,
                        'full_info': f"链接: {link_text} -> {absolute_url} [相关性: {relevance_score}/10]",
                        'relevance_score': relevance_score
                    })
            
            # 按相关性排序链接
            links.sort(key=lambda x: x['relevance_score'], reverse=True)
            
            # 标记为已爬取
            self.mark_url_as_crawled(url)
            
            print(f"✅ 成功爬取网页内容，字符数: {len(cleaned_content)}，发现链接数: {len(links)}")
            return cleaned_content, links
            
        except Exception as e:
            print(f"❌ 网页爬取失败: {e}")
            # 即使爬取失败也标记为已尝试，避免重复尝试
            self.mark_url_as_crawled(url)
            raise Exception(f"网页爬取失败: {e}")

    def fetch_content(self, url, local_base_dir=""):
        """
        统一的内容获取函数，支持http/https和file://协议
        """
        parsed = urlparse(url)
        
        if parsed.scheme in ['http', 'https']:
            return self.fetch_webpage_content(url)
        elif parsed.scheme == 'file':
            # 处理file:// URL
            file_path = parsed.path
            
            # 在Windows上，file:///C:/path 会变成 /C:/path，需要去掉开头的/
            if sys.platform == 'win32' and file_path.startswith('/'):
                file_path = file_path[1:]
            
            # 如果是相对路径，使用基础目录
            if local_base_dir and not os.path.isabs(file_path):
                file_path = os.path.join(local_base_dir, file_path)
            
            content, links = self.fetch_file_content(file_path)
            # 标记为已爬取
            self.mark_url_as_crawled(url)
            return content, links
        else:
            raise ValueError(f"不支持的URL协议: {parsed.scheme}")

    def calculate_relevance_score(self, link_text, url):
        """
        计算链接与目标关键词的相关性分数
        """
        score = 0
        
        # 检查链接文本中的关键词
        text_lower = link_text.lower()
        for keyword in self.target_keywords:
            if keyword.lower() in text_lower:
                score += 2
        
        # 检查URL路径中的关键词
        url_lower = url.lower()
        for keyword in self.target_keywords:
            if keyword.lower() in url_lower:
                score += 1
        
        # 基于链接文本长度的启发式评分
        if len(link_text) > 5 and len(link_text) < 50:
            score += 1
        
        return min(score, 10)

    def is_valid_url(self, url):
        """验证URL是否有效"""
        try:
            parsed = urlparse(url)
            if parsed.scheme in ['http', 'https']:
                return bool(parsed.netloc) and bool(parsed.scheme)
            elif parsed.scheme == 'file':
                # 对于file:// URL，检查路径是否存在（如果是绝对路径）
                file_path = parsed.path
                if sys.platform == 'win32' and file_path.startswith('/'):
                    file_path = file_path[1:]
                return bool(file_path)
            else:
                return False
        except:
            return False

    def add_urls_to_queue(self, urls):
        """将新的URL添加到队列末尾，自动过滤已爬取的URL"""
        new_urls_added = 0
        
        for url in urls:
            # 检查URL是否已经爬取过或已经在队列中
            if url not in self.target_urls and not self.is_url_crawled(url):
                self.target_urls.append(url)  # 添加到队列末尾
                new_urls_added += 1
                print(f"🎯 已添加目标链接到队列末尾: {url}")
            else:
                print(f"⏭️  跳过已存在或已爬取的URL: {url}")
        
        return new_urls_added

    def get_next_url(self):
        """从队列头部获取下一个未爬取的URL"""
        # 循环查找下一个未爬取的URL
        while self.target_urls:
            url = self.target_urls.popleft()  # 从队列头部取出
            if not self.is_url_crawled(url):
                return url
            else:
                print(f"⏭️  跳过已爬取的URL: {url}")
        
        return None

    def get_remaining_urls_count(self):
        """获取剩余未爬取的URL数量"""
        # 只计算未爬取的URL
        return len([url for url in self.target_urls if not self.is_url_crawled(url)])

    def get_tools_functions(self, prompt_type="link_identifier"):
        """根据提示词类型定义不同的工具函数"""
        base_functions = [
            {
                "type": "function",
                "function": {
                    "name": "add_target_links",
                    "description": "将可能包含目标内容的链接添加到爬取队列中",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "links": {
                                "type": "array",
                                "items": {
                                    "type": "object",
                                    "properties": {
                                        "url": {
                                            "type": "string",
                                            "description": "完整的URL链接"
                                        },
                                        "reason": {
                                            "type": "string", 
                                            "description": "为什么认为这个链接可能包含目标内容"
                                        },
                                        "confidence": {
                                            "type": "string",
                                            "enum": ["high", "medium", "low"],
                                            "description": "对这个链接包含目标内容的置信度"
                                        }
                                    },
                                    "required": ["url", "reason", "confidence"]
                                },
                                "description": "可能包含目标内容的链接列表"
                            }
                        },
                        "required": ["links"]
                    }
                }
            }
        ]
        
        # 根据提示词类型添加不同的工具函数
        if prompt_type in ["content_analyzer", "file_analyzer", "spider"]:
            base_functions.append({
                "type": "function",
                "function": {
                    "name": "analyze_content",
                    "description": "分析页面内容并给出详细总结",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "summary": {
                                "type": "string",
                                "description": "页面内容总结"
                            },
                            "key_points": {
                                "type": "array",
                                "items": {"type": "string"},
                                "description": "关键信息点"
                            },
                            "content_quality": {
                                "type": "string",
                                "enum": ["excellent", "good", "average", "poor"],
                                "description": "内容质量评估"
                            },
                            "content_type": {
                                "type": "string",
                                "enum": ["news", "article", "blog", "forum", "ecommerce", "portal", "document", "code", "data", "other"],
                                "description": "页面内容类型"
                            },
                            "topic_tags": {
                                "type": "array",
                                "items": {"type": "string"},
                                "description": "页面主题标签"
                            }
                        },
                        "required": ["summary", "key_points", "content_quality", "content_type", "topic_tags"]
                    }
                }
            })
        
        return base_functions

    def process_tool_calls(self, tool_calls, current_url, all_links, prompt_type="link_identifier"):
        """处理DeepSeek返回的工具调用"""
        results = []
        urls_added = []
        
        for tool_call in tool_calls:
            function_name = tool_call['function']['name']
            function_args = json.loads(tool_call['function']['arguments'])
            
            if function_name == "add_target_links":
                links_to_add = function_args['links']
                new_urls_count = 0
                
                for link_info in links_to_add:
                    url = link_info['url']
                    reason = link_info['reason']
                    confidence = link_info['confidence']
                    
                    # 验证URL是否在可用链接中
                    available_urls = [link['url'] for link in all_links]
                    if url in available_urls:
                        # 使用add_urls_to_queue函数，它会自动过滤已爬取的URL
                        added_count = self.add_urls_to_queue([url])
                        if added_count > 0:
                            urls_added.append({
                                'url': url,
                                'reason': reason,
                                'confidence': confidence
                            })
                            new_urls_count += 1
                    else:
                        print(f"⚠️ 警告: URL不在当前页面链接中: {url}")
                
                if new_urls_count > 0:
                    print(f"✅ 成功添加 {new_urls_count} 个新链接到队列末尾")
            
            elif function_name == "analyze_content" and prompt_type in ["content_analyzer", "file_analyzer", "spider"]:
                summary = function_args['summary']
                key_points = function_args['key_points']
                content_quality = function_args['content_quality']
                content_type = function_args.get('content_type', 'other')
                topic_tags = function_args.get('topic_tags', [])
                
                # 存储页面总结
                page_summary = {
                    'url': current_url,
                    'summary': summary,
                    'key_points': key_points,
                    'content_quality': content_quality,
                    'content_type': content_type,
                    'topic_tags': topic_tags
                }
                self.page_summaries.append(page_summary)
                
                results.append({
                    'type': 'content_analysis',
                    'summary': summary,
                    'key_points': key_points,
                    'content_quality': content_quality,
                    'content_type': content_type,
                    'topic_tags': topic_tags
                })
        
        return urls_added, results

    def analyze_single_url(self, url, api_key_file="deepseek.key", prompt_file="prompts/link_identifier.txt", local_base_dir=""):
        """
        分析单个URL，根据提示词类型执行不同的任务
        """
        # 加载 API 密钥和提示词
        api_key = self.load_file(api_key_file)
        if not api_key or api_key == "your-deepseek-api-key-here":
            raise Exception("请配置正确的DeepSeek API密钥")
        
        base_prompt_template = self.load_file(prompt_file)
        # 动态替换关键词
        base_prompt = base_prompt_template.format(keywords=', '.join(self.target_keywords))
        
        # 根据提示词文件名确定类型
        prompt_type = "link_identifier"
        if "content_analyzer" in prompt_file:
            prompt_type = "content_analyzer"
        elif "spider" in prompt_file:
            prompt_type = "spider"
        elif "file_analyzer" in prompt_file:
            prompt_type = "file_analyzer"
        
        print(f"\n{'='*60}")
        print(f"🔍 正在分析资源 ({prompt_type}): {url}")
        print(f"{'='*60}")
        
        try:
            # 获取内容（支持网页和文件）
            webpage_content, all_links = self.fetch_content(url, local_base_dir)
            
            # 如果页面内容为空（可能是已爬取跳过），直接返回
            if not webpage_content and not all_links:
                return {
                    'url': url,
                    'prompt_type': prompt_type,
                    'analysis': "资源已爬取，跳过分析",
                    'added_urls': [],
                    'analysis_results': [],
                    'links_found': 0,
                    'high_relevance_links': 0,
                    'success': True,
                    'skipped': True
                }
            
            # 显示高相关性链接
            high_relevance_links = [link for link in all_links if link['relevance_score'] >= 5]
            if high_relevance_links and prompt_type == "link_identifier":
                print(f"\n📈 发现 {len(high_relevance_links)} 个高相关性链接:")
                for link in high_relevance_links[:3]:
                    print(f"   • {link['text']}")
                    print(f"     -> {link['url']} [分数: {link['relevance_score']}]")
            
            # 根据提示词类型构建不同的提示词
            if prompt_type == "link_identifier":
                links_preview = '\n'.join([link['full_info'] for link in all_links[:20]])
                full_prompt = f"""{base_prompt}

当前资源URL: {url}

资源内容摘要（仅供上下文参考）:
{webpage_content[:1500]}...

当前资源发现的所有链接 (共{len(all_links)}个，按相关性排序):
{links_preview}
{'... (更多链接已隐藏)' if len(all_links) > 20 else ''}

请使用工具函数将3-8个最有价值的链接添加到爬取队列中。"""
                
                tool_choice = {"type": "function", "function": {"name": "add_target_links"}}
            
            elif prompt_type in ["content_analyzer", "file_analyzer"]:
                full_prompt = f"""{base_prompt}

资源URL: {url}

资源完整内容:
{webpage_content[:4000]}...

请分析这个资源的主要内容，总结关键信息，并评估内容质量。"""
                
                tool_choice = "auto"
            
            else:  # spider或其他类型
                links_preview = '\n'.join([link['full_info'] for link in all_links[:15]])
                full_prompt = f"""{base_prompt}

资源URL: {url}

资源内容:
{webpage_content[:3000]}...

发现链接 (共{len(all_links)}个):
{links_preview}

请分析资源内容并识别有价值的信息。"""
                
                tool_choice = "auto"
            
            # API 调用
            api_url = "https://api.deepseek.com/v1/chat/completions"
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {api_key}"
            }
            data = {
                "model": "deepseek-chat",
                "messages": [{"role": "user", "content": full_prompt}],
                "stream": False,  # 固定为非流式输出
                "temperature": 0.3,
                "tools": self.get_tools_functions(prompt_type),
                "tool_choice": tool_choice
            }
            
            print(f"\n🤖 正在调用 DeepSeek API ({prompt_type})...")
            
            # 直接使用非流式API调用
            result_content, tool_calls = self.deepseek_chat_normal(api_url, headers, data)
            
            # 处理工具调用
            added_urls = []
            analysis_results = []
            if tool_calls:
                print(f"\n🛠️ 检测到工具调用，正在处理...")
                added_urls, analysis_results = self.process_tool_calls(tool_calls, url, all_links, prompt_type)
                if added_urls:
                    print(f"✅ 成功添加 {len(added_urls)} 个新链接到队列末尾")
                    for added in added_urls[:3]:  # 只显示前3个
                        print(f"   • {added['url']} (置信度: {added['confidence']})")
                else:
                    print("ℹ️  未添加新链接（可能都是重复链接）")
                
                if analysis_results:
                    for result in analysis_results:
                        if result['type'] == 'content_analysis':
                            print(f"📊 内容分析结果 - 质量: {result['content_quality']}")
                            print(f"   类型: {result['content_type']}")
                            print(f"   主题标签: {', '.join(result['topic_tags'][:5])}")
                            print(f"   总结: {result['summary'][:200]}...")
            
            # 返回结果
            return {
                'url': url,
                'prompt_type': prompt_type,
                'analysis': result_content,
                'added_urls': added_urls,
                'analysis_results': analysis_results,
                'links_found': len(all_links),
                'high_relevance_links': len(high_relevance_links),
                'success': True,
                'skipped': False
            }
            
        except Exception as e:
            print(f"❌ 处理资源 {url} 时出错: {e}")
            return {
                'url': url,
                'prompt_type': prompt_type,
                'error': str(e),
                'analysis': '',
                'added_urls': [],
                'analysis_results': [],
                'success': False,
                'skipped': False
            }

    def deepseek_chat_normal(self, url, headers, data):
        """普通API调用（非流式）"""
        response = requests.post(url, headers=headers, json=data, timeout=60)
        response.raise_for_status()
        result = response.json()
        
        message = result["choices"][0]["message"]
        content = message.get("content", "")
        tool_calls = message.get("tool_calls", [])
        
        if content:
            print("\n🤖 DeepSeek 回复:")
            print("-" * 40)
            print(content)
            print("-" * 40)
        
        return content, tool_calls

    def generate_overall_summary(self):
        """生成整体总结报告"""
        if not self.page_summaries:
            return "暂无资源总结数据"
        
        print(f"\n{'='*60}")
        print("📊 整体爬取总结报告")
        print(f"{'='*60}")
        
        # 统计内容质量分布
        quality_stats = defaultdict(int)
        content_type_stats = defaultdict(int)
        all_topic_tags = []
        
        for summary in self.page_summaries:
            quality_stats[summary['content_quality']] += 1
            content_type_stats[summary['content_type']] += 1
            all_topic_tags.extend(summary['topic_tags'])
        
        # 统计热门主题标签
        tag_freq = defaultdict(int)
        for tag in all_topic_tags:
            tag_freq[tag] += 1
        top_tags = sorted(tag_freq.items(), key=lambda x: x[1], reverse=True)[:10]
        
        print(f"\n📈 内容质量分布:")
        for quality, count in quality_stats.items():
            print(f"   {quality}: {count} 个资源")
        
        print(f"\n🏷️  内容类型分布:")
        for content_type, count in content_type_stats.items():
            print(f"   {content_type}: {count} 个资源")
        
        print(f"\n🔥 热门主题标签:")
        for tag, freq in top_tags:
            print(f"   {tag}: {freq} 次")
        
        # 生成总体评价
        total_pages = len(self.page_summaries)
        excellent_pages = quality_stats.get('excellent', 0)
        good_pages = quality_stats.get('good', 0)
        
        quality_ratio = (excellent_pages + good_pages) / total_pages if total_pages > 0 else 0
        
        print(f"\n📋 总体评价:")
        print(f"   分析资源总数: {total_pages}")
        print(f"   优质内容比例: {quality_ratio:.1%}")
        print(f"   内容多样性: {len(content_type_stats)} 种类型")
        print(f"   主题丰富度: {len(set(all_topic_tags))} 个不同主题")
        
        # 显示最有价值的资源
        excellent_summaries = [s for s in self.page_summaries if s['content_quality'] == 'excellent']
        if excellent_summaries:
            print(f"\n🏆 高质量资源推荐:")
            for i, summary in enumerate(excellent_summaries[:3], 1):
                print(f"   {i}. {summary['url']}")
                print(f"      主题: {', '.join(summary['topic_tags'][:3])}")
                print(f"      摘要: {summary['summary'][:100]}...")
        
        return {
            'total_pages': total_pages,
            'quality_stats': dict(quality_stats),
            'content_type_stats': dict(content_type_stats),
            'top_tags': dict(top_tags),
            'quality_ratio': quality_ratio
        }

    def main_loop(self, api_key_file="deepseek.key", prompt_files=None, max_iterations=10, local_base_dir="", auto_select_prompt=False):
        """
        主循环：支持不同的提示词文件轮换使用
        """
        if prompt_files is None:
            prompt_files = ["prompts/link_identifier.txt"]
        
        all_results = []
        iteration = 0
        prompt_index = 0
        
        print("🎯 开始智能资源分析循环...")
        print(f"📁 使用的提示词文件: {prompt_files}")
        print(f"🎯 目标关键词: {', '.join(self.target_keywords)}")
        print(f"📝 已爬取URL记忆: {self.get_crawled_urls_count()} 个")
        if local_base_dir:
            print(f"📂 本地基础目录: {local_base_dir}")
        if auto_select_prompt:
            print(f"🤖 自动提示词选择: 已启用")
        
        while iteration < max_iterations:
            iteration += 1
            
            # 从队列头部获取下一个未爬取的URL
            current_url = self.get_next_url()
            if not current_url:
                print("📭 没有更多未爬取的URL，分析结束")
                break
            
            # 选择提示词
            if auto_select_prompt:
                # 自动选择提示词
                current_prompt_file = self.auto_select_prompt(current_url, prompt_files)
                print(f"🤖 自动选择提示词: {current_prompt_file}")
            else:
                # 轮换使用不同的提示词文件
                current_prompt_file = prompt_files[prompt_index]
                prompt_index = (prompt_index + 1) % len(prompt_files)
            
            print(f"\n🔄 第 {iteration} 次迭代")
            print(f"📋 当前分析: {current_url}")
            print(f"📝 使用提示词: {current_prompt_file}")
            print(f"📦 剩余未爬取URL: {self.get_remaining_urls_count()}")
            print(f"📝 已爬取URL总数: {self.get_crawled_urls_count()}")
            
            # 分析当前URL
            result = self.analyze_single_url(
                url=current_url,
                api_key_file=api_key_file,
                prompt_file=current_prompt_file,
                local_base_dir=local_base_dir
            )
            
            all_results.append(result)
            
            # 显示当前队列状态（只显示未爬取的）
            unvisited_queue = [url for url in list(self.target_urls)[:5] if not self.is_url_crawled(url)]
            if unvisited_queue:
                print(f"\n📚 当前队列头部未爬取URL:")
                for i, queue_url in enumerate(unvisited_queue, 1):
                    print(f"   {i}. {queue_url}")
            
            # 检查是否达到最大迭代次数或没有更多URL
            if iteration >= max_iterations:
                print(f"\n⏹️  达到最大迭代次数: {max_iterations}")
                break
            elif self.get_remaining_urls_count() == 0:
                print(f"\n📭 没有更多未爬取的URL")
                break
            else:
                print(f"\n⏭️  自动继续到下一个URL...")
        
        # 生成整体总结
        overall_summary = self.generate_overall_summary()
        
        return all_results, overall_summary

    def run(self):
        """运行主程序"""
        try:
            # 解析命令行参数
            args = self.parse_arguments()
            
            # 更新目标关键词
            self.update_keywords(args.keywords)
            
            # 解析提示词文件
            prompt_files = [f.strip() for f in args.prompt_files.split(',') if f.strip()]
            
            # 从命令行参数和文件加载URL
            initial_urls = self.load_urls_from_args_and_file(args)
            
            print(f"\n{'='*60}")
            print("🚀 智能网页和文件系统资源分析工具启动")
            print(f"{'='*60}")
            print(f"📊 配置信息:")
            print(f"   最大迭代次数: {args.iterations}")
            print(f"   API密钥文件: {args.api_key_file}")
            print(f"   初始URL数量: {len(initial_urls)}")
            if args.urls_file:
                print(f"   URL文件: {args.urls_file}")
            print(f"   提示词文件: {', '.join(prompt_files)}")
            print(f"   目标关键词: {', '.join(self.target_keywords)}")
            if args.local_base_dir:
                print(f"   本地基础目录: {args.local_base_dir}")
            if args.auto_select_prompt:
                print(f"   自动提示词选择: 已启用")
            print(f"   支持协议: http, https, file://")
            print(f"   初始URL列表:")
            for i, url in enumerate(initial_urls[:5], 1):
                print(f"     {i}. {url}")
            if len(initial_urls) > 5:
                print(f"     ... 还有 {len(initial_urls) - 5} 个URL")
            print(f"{'='*60}")
            
            # 执行主循环，轮换使用不同的提示词
            results, overall_summary = self.main_loop(
                api_key_file=args.api_key_file,
                prompt_files=prompt_files,
                max_iterations=args.iterations,
                local_base_dir=args.local_base_dir,
                auto_select_prompt=args.auto_select_prompt
            )
            
            # 显示总结
            print(f"\n{'='*60}")
            print("🎯 智能资源分析总结")
            print(f"{'='*60}")
            
            successful_analyses = [r for r in results if r.get('success')]
            failed_analyses = [r for r in results if not r.get('success')]
            skipped_analyses = [r for r in results if r.get('skipped', False)]
            
            total_added_urls = sum(len(r.get('added_urls', [])) for r in successful_analyses)
            total_high_relevance = sum(r.get('high_relevance_links', 0) for r in successful_analyses)
            
            # 按提示词类型统计
            prompt_stats = {}
            for result in successful_analyses:
                if not result.get('skipped', False):  # 不统计跳过的
                    prompt_type = result.get('prompt_type', 'unknown')
                    if prompt_type not in prompt_stats:
                        prompt_stats[prompt_type] = 0
                    prompt_stats[prompt_type] += 1
            
            print(f"✅ 成功分析: {len(successful_analyses) - len(skipped_analyses)} 个资源")
            print(f"⏭️  跳过已爬取: {len(skipped_analyses)} 个资源")
            print(f"❌ 失败分析: {len(failed_analyses)} 个资源")
            print(f"🎯 添加目标链接: {total_added_urls} 个")
            print(f"📈 发现高相关性链接: {total_high_relevance} 个")
            print(f"📋 剩余未处理URL: {self.get_remaining_urls_count()}")
            print(f"📝 总爬取URL数: {self.get_crawled_urls_count()}")
            
            print(f"\n📊 提示词使用统计:")
            for prompt_type, count in prompt_stats.items():
                print(f"   {prompt_type}: {count} 次")

            print(f"\n📄 详细结果:")
            for i, result in enumerate(successful_analyses, 1):
                if not result.get('skipped', False):  # 不显示跳过的
                    print(f"\n第 {i} 个资源: {result['url']}")
                    print(f"   提示词类型: {result.get('prompt_type', 'unknown')}")
                    print(f"   发现链接数: {result['links_found']}")
                    print(f"   高相关性链接: {result.get('high_relevance_links', 0)}")
                    print(f"   添加目标链接: {len(result.get('added_urls', []))} 个")
            
            # 保存资源总结到文件
            if self.page_summaries:
                summary_file = "resource_summaries.json"
                with open(summary_file, 'w', encoding='utf-8') as f:
                    json.dump(self.page_summaries, f, ensure_ascii=False, indent=2)
                print(f"\n💾 资源总结已保存到: {summary_file}")
            
        except Exception as e:
            print(f"❌ 程序错误: {e}")
            sys.exit(1)


# 使用示例
if __name__ == "__main__":
    analyzer = WebResourceAnalyzer()
    analyzer.run()